package com.category.douyijia.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.category.douyijia.base.BaseModel;
import com.category.douyijia.model.Area;
import com.category.douyijia.model.Buyer;
import com.category.douyijia.model.CommLog;
import com.category.douyijia.model.Commodity;
import com.category.douyijia.model.Log;
import com.category.douyijia.model.LogArea;
import com.category.douyijia.model.LogOrd;
import com.category.douyijia.model.OrdMang;
import com.category.douyijia.model.OrdMaster;
import com.category.douyijia.model.Type;
import com.category.douyijia.services.AreaService;
import com.category.douyijia.services.LogService;
import com.category.douyijia.services.OrdMasterService;
import com.jfinal.aop.Before;
import com.jfinal.aop.Inject;
import com.jfinal.core.Controller;
import com.jfinal.core.NotAction;
import com.jfinal.core.Path;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.tx.Tx;


/**
 * 创建订单主表控制器
 * 可以设置所有订单主表
 * 它可以将那些订单主表更好的显现出来
 * @author jiangmengyang
 *@version v1.0
 *访问页面路径：douyijia.category.com+/ordmaster+"/"+action
 */
@Path("/ordmaster")
public class OrdMasterController  extends Controller{
		/**
		 * 商品信息表
		 */
		@Inject
		Commodity commodity;
		/**
		 * 订单管理
		 */
		@Inject
		OrdMang ordMang;
		/**
		  * 创建订单主表在服务文件中的dao 的工具
		  * 这个工具可以利用ordMasterService里面的，
		  * 增删改查的功能
		  */
		@Inject
		OrdMasterService ordMasterService;
		/**
		 * 订单主表
		 */
		@Inject
		OrdMaster ordMaster;
		/**
		 * 
		 */
		@Inject
		LogService logService;
		/**
		 * 物流信息表
		 */
		@Inject
		Log log;
		/**
		 * 商品类目
		 */
		Type type;
		/**
		 * 
		 */
		@Inject
		AreaService areaService;
		/**
		 * 地区表
		 */
		@Inject
		Area area;
		/**
		 * 物流订单表
		 */
		@Inject
		LogOrd logOrd;
		/**
		 * 
		 */
		@Inject
		Db db;
		/**
		 * 商品订单表
		 */
		@Inject
		CommLog commLog;
		/**
		 * 
		 */
		@Inject
		Type typeId;
		/**
		 * 
		 */
		@Inject
		Buyer buyer;
		/**
		 * 
		 */
		@Inject
		LogArea logArea;
		@Inject
		Commodity commRepertory;
	    /**
	     * 创建一个非action的方法，
	     * 用于查询订单主表里的信息
	     * @return
	     * 返回所有订单主表的信息
	     */
	@SuppressWarnings({"unchecked","rawtypes"})
	@NotAction
	    public List<OrdMaster> ordMasterAll() {
			return (ArrayList)ordMasterService.ordMasterDao.findAll();
	    }
	/**
	  * 创建一个保存页面模板的方法，
	  * 用于保存页面静态模板
	  */
	    
	 @NotAction
	 private void keepModel() {
		 /*
		  * 创建一个保存多参数的模板，
		  * 在不指定数据类型文件时，
		  * 默认为string的类型
		  */
		 keepPara("ordMasterId","buyerTel");
		/*
		 * 创建一个多参数模板，
		 * 指定参数类型为整型
		 */
		 keepPara(Integer.class,"payState","totalMoney");
		 /*
		  * 创建一个多参数模板，
		  * 指定参数类型为字符串
		  */
		 keepPara(String.class,"buyerSite","buyerName") ;
		 /*
		  * 创建一个参数模板
		  * 指定参数类型为整型
		  */
		 keepPara(Integer.class,"ordState");
		 /*
		  * 创建一个参数模板
		  * 指定参数类型为整型
		  */
		 keepPara(Integer.class,"deleteState");
		 /*
		  * 创建一个多参数模板，
		  * 指定参数类型为Date
		  */
		 keepPara(Date.class,"turnoverTime","creationTime");
	 }
	 /**
	  * 创建一个添加订单主表的服务页面
	  * 使用服务器提供的模板生成页面
	  * 主要用于往页面里添加数据
	  */
	 public void  addtion(){
		 //设置保存数据模板
		 keepModel();
		 //设置网页的模板
		 render("ordmaster_addtion.jsp");
	 }
	 /**
	  *创建一个非action得方法
	  *查找是私有的，在页面内进行的
	  * @param ordMasterId
	  * 通过ordMasterId查找订单主表
	  * @return
	  * 返回一个订单主表对象
	  */
	 @NotAction
	 private OrdMaster findByOrdMasterId(String ordMasterd) {
	 		/*
	 		 * 如果ordMasterd不为空结果返回一个订单主表对象，
	 		 * 查找订单主表表里的所有列
	 		 * 如果ordMasterd为空，
	 		 * 则返回值为空
	 		 */
		   if(ordMasterd!=null && !(ordMasterd.equals(""))) {
			   //this.ordMaster等于上面建立的实体类的对象
				   return (OrdMaster)ordMasterService.ordMasterDao.find(
						   "select"
								   + "ord_master_id,ord_state,total_money,pay_state,"
			 		 				+ "turnover_time,creation_time,"
			 		 				+ "buyer_site,buyer_tel,buyer_name,delete_state"
			 		 				+ " from t_ord_master "
			 		 				+ "where ord_master_id"
			 		 				+ "= ? ",  ordMasterd);	
		   }else {
			   //否则返回空值
			   return null;
		   }
	   }
	 	/**
	 	 * 如果ordMaster不为空则跳转另一个页面
	 	 * 如果ordMaster为空则返回原来的页面
	 	 * 进行页面跳转则用public
	 	 * @param ordMaster
	 	 * 原来的实体类的一个对象
	 	 * @param ordMasterId
	 	 * 通过ordMasterId去查找订单主表,
	 	 * 再进行更改
	 	 */
	 	public void update_by_ord_master_id( OrdMaster ordMaster,  String ordMasterId){
	 		if(ordMasterId!=null && !(ordMasterId.equals(""))){
	 			/*
	 			 * oldOrdMaster=this.ordMater=ordMasterId
	 			 * 创建一个原来的地址
	 			 */
	 			OrdMaster oldOrdMaster= findByOrdMasterId(ordMasterId);
	 			//判断查找到的结果是否为空
	 			if (oldOrdMaster == null) {
	 				//如果为空，返回主页面
	 				render("ordmaster_index.jsp");
				}else {
					//否则通过service进行更新
		 			this.ordMasterService.ordMasterDao._setAttrs(ordMaster).update();
		 			render("ordmaster_success.jsp");
				}
	 		}else {
				render("ordmaster_index.jsp");
			}
	 	}
	 /**
	  * 如果订单主表里的信息没有错误的话，
	  * 开发者科管理员可以访问并修改页面信息
	  */
	 public void index() {
		 render("ordmaster_index.jsp");
	 }
	 public boolean updateById(String ordId,OrdMaster ordMaster){
		 
		return false;
		 
	 }
	 /**
	  * 通过商品类目查找商品信息
	  * @param typeId
	  * 商品类型id
	  * @return
	  * 返回商品类型
	  */
	 @NotAction
	 @SuppressWarnings("unchecked")
	 @Before(Tx.class)
	 public List<Commodity> findCommodityByTypeId(String typeId){
		 //创建商品类型集合
		 List<Commodity> commoditiesList = new ArrayList();
		 //查找商品类型
		 type = (Type) type.dao().findById(typeId);
		 //判断商品类目是否为空
		 if (type != null) {
			 //不为空查询商品信息
			 commoditiesList = (List<Commodity>) commodity.dao().find("select comm_id"
			 														+ ",comm_name"
			 														+ ",comm_repertory"
			 														+ ",comm_univalence"
			 														+ ",comm_prcture"
			 														+ ",comm_describe"
			 														+ ",comm_type_id from t_commodity where comm_type_id = ? "
			 														,type.getTypeId());
			 //返回查找到的结果，否则执行事务处理返回空
			 return commoditiesList;
		}else {
			//否则返回空
			return null;
		}
	 }
	 /**
	  * 通过商品编号查找订单主表
	  * @param commId
	  * @return
	  */
	 @NotAction
	 @SuppressWarnings("unchecked")
	 @Before(Tx.class)
	 public List<OrdMaster> findOrdMasterByCommId(String commId){
		 //创建主表订单集合
		 List<OrdMaster> ordmasterList = new ArrayList();
		 //查找商品信息
		 commodity = (Commodity)commodity.dao().findById(commId);
		 //判断订单主表是否为空
		 if(commodity!=null){
			 //不为空查询订单主表信息
			 ordmasterList= (List<OrdMaster>)ordMaster.dao().find("select"
					            + "ord_master_id,ord_state,total_money,pay_state,"
		 		 				+ "turnover_time,creation_time,"
		 		 				+ "buyer_site,buyer_tel,buyer_name,delete_state"
		 		 				+ " from t_ord_master "
		 		 				+ "where ord_master_id"
		 		 				+ "= ? ",  commodity.getCommId());	
			//返回查找到的结果，否则执行事务处理返回空
			 return ordmasterList;
		 }else{
			 //否则返回空值
			 return null;
		 } 
	 }
	/**
	 * 通过订单主表编号查询物流订单信息
	 * @param ordMasterId
	 * @return
	 */
	@NotAction
	@SuppressWarnings("unchecked")
	@Before(Tx.class)
	public List<LogOrd> findLogOrdByOrdMasterId(String ordMasterId) {
		 //创建物流信息订单集合
		 List<LogOrd> logOrdList = new ArrayList();
		 //查询订单主表类型
		 ordMaster = (OrdMaster) ordMaster.dao().findById(ordMasterId);
		 //判断订单主表时候为空
		 if(ordMaster!=null) {
			//不为空查询物流信息表里的内容
			logOrdList = (List<LogOrd>) logOrd.dao().find("select"
		      		+ "id,log_id,ord_id "
		      		+ "from t_log_ord "
		      		+ "where log_id"
		      		+ " =?",ordMaster.getOrdId());
		    //返回查找到的结果，否则执行事务处理返回空
		    return logOrdList;
		}else{
			//否则
			return null;
		}
	 }
	/**
	 * 通过商品编号查找商品信息
	 * @param commId
	 * 商品编号
	 * @return
	 */
	@NotAction
	@SuppressWarnings("unchecked")
	@Before(Tx.class)
	public List<CommLog> findCommLogByCommId(String commId){
		//创建商品集合
		List<CommLog> commLogList = new ArrayList();
		//查找商品类型
		commodity = (Commodity)commodity.dao().findById(commId);
		//判断商品是否为空
		if(commodity!=null){
			//不为空查询商品信息表里的内容
			commLogList= (List<CommLog>)commLog.dao().find("select"
								+ "id,comm_id,log_id"
		 		 				+ " from t_comm_log "
		 		 				+ "where comm_id"
		 		 				+ "= ? ",  commodity.getCommId());	
			//返回查找到的结果，否则执行事务处理返回空
			return commLogList;
		}else{
			//执行事务处理返回空
			return null;
		}
	 }
	 /**
	  * 通过商品id添加订单
	  * @param commId
	  * 商品id
	  * @param ordMaster
	  * 订单主表
	  * @param comQuantity
	  * 购买数量
	  * @return
	  * 执行结果，
	  * 执行成功添加返回true，
	  * 否则返回false
	  */
	 @NotAction
	 @Before(Tx.class)
	 public boolean putLogBycommodityId(String commId,OrdMaster ordMaster,int comQuantity) {
		//设置默认值
		boolean result = false;
		if (
				commId != null
				&&
				!(commId.equals(""))
				&&
				ordMaster != null
				&&
				comQuantity >0
			){
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddkkmmss");
			//查找商品编号并保存
			commodity = (Commodity)commodity.dao().findById(commId);
			//判断商品数量
			if ((commodity.getCommRepertory() - comQuantity) >= 0) {
				//生成订单编号算法
				String ordId = sdf.format(date) 
						 		+ commodity.getCommId() 
						 		+ commodity.getCommPrcture();
				 //添加属性
				ordMang.setComId(commodity.getCommId());
				ordMang.setComName(commodity.getCommName());
				ordMang.setComPicture(commodity.getCommPrcture());
				ordMang.setComPrice(commodity.getCommUnivalence());
				ordMang.setComQuntity(comQuantity);
				ordId = ordId + comQuantity + buyer.getBuyerTel() + buyer.getId();
				ordMang.setOrdId(ordId); 
				//生成订单详情表
				ordMang.dao().save();
				//通过订单详情表查找买家信息
				buyer = (Buyer) buyer.dao().find("select* from t_buyer where ord_master_id =? ", ordId);
				//生成订单主表
				result = ordMaster._setAttrs(ordMaster).save();
				//商品库存数量减少对应购买数量
				int count = commodity.getCommRepertory() - comQuantity;
				if (count>=0 && result) {
					//修改商品库存
					result= commodity.dao().set("commRepertory", count).update();
				}
			}
			 //通过订单id查找并返回订单状态
			 return result;
		}else {
			return false;
		}
	 }
	 
	 /**
	  * 更新订单状态
	  * @param ordId
	  * 订单编号
	  * @param payState
	  * 订单支付状态
	  * @param deleteState
	  * 订单删除状态
	  * @return
	  * 返回执行结果
	  */
	 @NotAction
	 @Before(Tx.class)
	 public boolean updateOrdMaasterByOrdId(String ordId,int payState,int deleteState){
		 //设置结果变量，默认为false
		 boolean result = false;
		 //创建更新时间
		 Date date = new Date();
		 //创建格式化时间对象
		 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss");
		 //格式化时间
		 sdf.format(date);
		 //
		 if (ordId != null && !(ordId.equals(""))) {
			ordMaster = (OrdMaster) ordMaster.dao().findById(ordId);
			if (ordMaster != null) {
				result = ordMaster.set("payState", payState).set("deleteState", deleteState).set("turnoverTime", sdf).dao().update();
				return result;
			}
		}
		 return result;
	 }
	/**
	 * 订单发货业务
	 * @param ordId
	 * 订单编号
	 * @param logName
	 * 物流公司名称
	 * @param areaName
	 * 所在地区
	 * @return
	 * 执行结果
	 */
	@NotAction
	@Before(Tx.class)
	public boolean putLogByCommId(String ordId,String logName,String areaName) {
		//创建结果变量
		boolean result = false;
		if(
			ordId!=null
			&&
			!(ordId.equals(""))
			&&
			logName!=null
			&&
			!(logName.equals(""))
			){
				//通过物流公司名称查找物流公司
				log = (Log) log.dao().find("select * from t_log where log_name = ?", logName);
				if(log.getLogState()==1){
					//设置变量接收物流公司编号
					String logId = log.getId();
					//创建物流订单表对象添加参数
					logOrd.setLogId(logId);
					logOrd.setOrdId(ordId);
					//物流订单对象用dao添加数据，并传给结果变量
					result = logOrd.dao().save();
					//判断变量结果是否为true，如果为true执行下面的步骤
					if (result) {
						//通过地区名称查找地区对象
						area = (Area) area.dao().find("select * from t_area where area_name = ? ", areaName);
						//设置变量接收地区编号
						String areaId = area.getId();
						//地区物流对象添加参数
						logArea.setAreaId(areaId);
						logArea.setLogComId(logId);
						//地区物流对象用dao添加数据
						result = logArea.dao().save();
					}
					return result;
				}
				return result;
		  }
		return result;  
	  }
	 /**
	  * 通过类目上传商品信息
	  * @param typeName
	  * 类目名称
	  * @param com
	  * 商品信息
	  * @return
	  * 执行结果true或false
	  */
	 @NotAction
	 @Before(Tx.class)
	 public boolean putCommodityByTypeId(String typeName,Commodity com){
		//创建接收结果的变量
		 boolean result = false;
		//判断类目名称是否为空或空字符串，判断商品是否为空对象
		 if(typeId!=null && !(typeId.equals("")) && com != null){
			//不为空把商品传递给commodity对象
			commodity = com;
			//通过名称查询类目对象
			type = (Type) type.dao().find("select * from t_type where type_name =?", typeName);
			//设置一个变量接收类目
			String typeId = type.getTypeId();
			//判断变量是否为空或空字符串
			if (typeId != null && !(typeId.equals(""))) {
				//判断商品信息对象是否为空对象
				if (commodity != null) {
					//不为空
					//commodity对象进行添加商品信息，并把结果传给保存结果的变量
					result = commodity.dao().save();
					//返回结果变量
					return result;
				}else {
					//为空
					//对com对象进行添加商品信息，并把结果传给保存结果的变量
					commodity = (Commodity) new Commodity()._setAttrs(com);
					 return commodity.dao().save();
				}
			}
		 }
		//返回结果变量
		return false;
	 }
	 /**
	  * 
	  * @param LogId
	  * @param ordMasterId
	  * @return
	  */
	 @NotAction
	 @Before(Tx.class)
	 public boolean putOrdMasterByLogId(String LogId,String ordMasterId){
		 //设置变量保存返回结果
		 boolean result=false;
		 //通过物流公司编号查找物流公司
		 log = (Log)log.dao().find("select *"
		 		+ "from t_log"
		 		+ " where log_id "
		 		+ "= ?",LogId);
		 //通过订单编号查找订单
		 ordMaster = (OrdMaster)ordMaster.dao().
				 find("selcet * "
		 		+ "from t_ord_master"
		 		+ " =?",ordMasterId);
		 //设置物流信息表中的id接收对象的id编号
		 String logId = log.getId();
		 //设置订单主表id接收对象的id编号
		 String orId = ordMaster.getOrdId();
		 //判断两个id是否为空
		 if(logId!=null && !(logId.equals("")) 
				 && orId!=null
				 && !(orId.equals(""))){
			 //传值给物流订单表
			 logOrd.setLogId(logId);
			 logOrd.setOrdId(orId);
			 //添加订单物流表对象，用结果变量接收
			 result = logOrd.dao().save(); 
		 }
		 //返回执行结果
		 return result;
	 }
}
